﻿/*-------------------------------------------------------------------------
* 命名空间: WaferSelectV3.Common/MsgParserHelper
* 类       名: MsgParserHelper
* 功      能:  TD
* 时      间:  2024-05-15 16:13:36
* 版      本:  V1.0
* 作      者:  Fioman
* 格      言:  Talk is cheap,show me the code ^_^
*-------------------------------------------------------------------------*/
using Microsoft.IdentityModel.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WaferSelectV3.Extensions;
using WaferSelectV3.Services;

namespace WaferSelectV3.Common
{
    public class MsgParserHelper
    {
        /// <summary>
        /// 解析尺寸的消息,如果失败,失败里面保存的消息就是要发送给客户端的消息
        /// 边长最大值，边长最小值，x边长，y边长，对角线左上右下，对角线左下右上，倒角最大值，倒角最小值，上下平行度，左右平行度，直角边最大值，
        /// 直角边最小值，垂直度最大值，垂直度最小值，左上倒角边长，右上倒角边长，左下倒角边长，右下倒角边长，左上角度，右上角度，左下角度，右下角度,
        /// X边长最大值,X边长最小值,Y边长最大值,Y边长最小值
        /// PC5,15,1,21,20230207010321， ERROR， 00，End  错误消息长度为8
        /// PC2,15,0,0,20230207010321,Clear,OK,End
        /// </summary>
        /// <param name="msgRec"></param>
        /// <returns>[流水号,pc名称,相机编号,内容],如果出错内容就是错误类型,如果不出错,后面就是保存到具体的内容,</returns>
        public static DataResult<List<string>> ParseSizeClientMsg(string msgRec)
        {
            DataResult<List<string>> result = new DataResult<List<string>>();
            try
            {
                // 保留空字符串,但是去除掉分隔后字符串两侧的空格
                string[] msgArray = msgRec.Split(',', StringSplitOptions.TrimEntries);
                if (msgArray.Length != 8 && msgArray.Length != 32)
                {
                    result.Message = $"消息格式错误,错误消息为: {msgRec}";
                    return result;
                }

                string pcName = msgArray[0]; // pc名称
                string cameraNum = msgArray[2]; // 相机编号
                string waferId = msgArray[3]; // 流水号
                                              // 处理错误消息
                if (msgArray.Length == 8)
                {
                    if (msgArray[5] == "ERROR")
                    {
                        string errorType = msgArray[6];
                        List<string> data = new List<string>()
                        {
                            waferId,
                            pcName,
                            cameraNum,
                            errorType
                        };
                        result.Data = data;
                        result.State = true;
                    }
                    else if (msgArray[5] == "Clear")
                    {
                        string ClearIsOK = msgArray[5] + msgArray[6];
                        List<string> data = new List<string>()
                        {
                            waferId,
                            pcName,
                            cameraNum,
                            ClearIsOK
                        };
                        result.Data = data;
                        result.State = true;
                    }

                }
                else if (msgArray.Length == 32)
                {
                    List<string> data = new List<string>()
                    {
                        waferId,
                        pcName,
                        cameraNum,
                    };
                    // 从索引为5的开始,然后最后一位数据不要.所以获取数据的个数是总长度减去6个,主要是多减去一个End
                    foreach (string msg in msgArray.Skip(5).Take(msgArray.Length - 6))
                    {
                        data.Add(msg);
                    }
                    result.Data = data;
                    result.State = true;
                }
                else
                {
                    result.Message = $"消息格式错误,解析到消息有效数据长度为8位,但是没有Error标识,接收到的消息为: {msgRec}";
                }

            }
            catch (Exception ex)
            {
                result.Message = ex.GetFullException();
            }
            return result;
        }

        //  崩边工位的数据分为左右,前后崩边,里面字符的个数就是19 + 1 / 2 ,以为少了一个逗号.
        //  PC2	19	 2	2018	20230716000000	 0	0	0	0	End
        //  崩边工位 数据长度 相机号 流水号 时间戳 左崩边有无   左崩边数量 左表崩有无   左表崩数量 结束符
        // PC2	19	 3	2018	20230716000000 0	0	0	0	End
        //  崩边工位 数据长度    相机号 流水号 时间戳 右崩边有无   右崩边数量 右表崩有无   右表崩数量 结束符
        // PC2	17	 0	2018	20230716000000  0 0	 0	End
        // 崩边工位 数据长度    相机号 流水号 时间戳 前崩边有无   前崩边数量 前崩边面积   结束符
        // PC2	17	 1	2018	20230716000000	 0 0	0	End
        // 崩边工位 数据长度    相机号 流水号 时间戳 后崩边有无   后崩边数量 后崩边面积   结束符
        /// <summary>
        /// 这里返回值的设计就很有学问了. 第一个数据应该存放的是[左右和前后],不用根据相机编号去区分左,还是右,即可.
        /// 如果数据出错还是返回[流水号,pc名称,相机编号,内容] 如果数据长度只有4个,就证明是检测到了数据异常情况,再去
        /// 处理异常结果.
        /// </summary>
        /// <param name="msgRec"></param>
        /// <returns>[流水号,pc名称,相机编号,内容]</returns>
        public static DataResult<List<string>> ParseEdgeClientMsg(string msgRec)
        {
            DataResult<List<string>> result = new DataResult<List<string>>();
            try
            {
                // 保留空字符串,但是去除掉分隔后的字符串两侧的空格
                string[] msgArray = msgRec.Split(',', StringSplitOptions.TrimEntries);
                if (msgArray.Length != 10 && msgArray.Length != 9 && msgArray.Length != 8)
                {
                    result.Message = $"消息长度错误,错误的消息为:{msgRec},解析逗号分隔之后长度为: {msgArray.Length},预设的长度为: (17,19),去除逗号之后为(9,10)";
                    return result;
                }

                string pcName = msgArray[0];
                string cameraNum = msgArray[2];
                string waferId = msgArray[3];
                if (msgArray.Length == 8)
                {
                    if (msgArray[5] == "ERROR")
                    {
                        string errorType = msgArray[6];
                        List<string> data = new List<string>()
                        {
                            waferId,
                            pcName,
                            cameraNum,
                            errorType
                        };
                        result.Data = data;
                        result.State = true;
                    }
                    else if (msgArray[5] == "Clear")
                    {
                        string ClearIsOK = msgArray[5] + msgArray[6];
                        List<string> data = new List<string>()
                        {
                            waferId,
                            pcName,
                            cameraNum,
                            ClearIsOK
                        };
                        result.Data = data;
                        result.State = true;
                    }
                }
                else if (msgArray.Length == 10)
                {
                    List<string> data = new List<string>()
                    {
                        waferId,
                        pcName,
                        cameraNum,
                    };
                    // 左右崩边,具体是哪个崩边,根据相机去判断.
                    // 左崩边返回的数据[左崩边有无,左崩边数量,左表崩有无,左表崩数量]
                    // 右崩边返回的数据[右崩边有无,右崩边数量,右表崩有无,右表崩数量]
                    foreach (string msg in msgArray.Skip(5).Take(msgArray.Length - 6))
                    {
                        data.Add(msg);
                    }
                    result.Data = data;
                    result.State = true;
                }
                else if (msgArray.Length == 9)
                {
                    // 前后崩边
                    List<string> data = new List<string>()
                    {
                        waferId,
                        pcName,
                        cameraNum,
                    };
                    // 前后崩边,具体是哪个崩边,根据相机去判断
                    // 前崩边返回数据[前崩边有无 前崩边数量,前崩边面积]
                    // 后崩边返回数据[后崩边有无 后崩边数量,后崩边面积]
                    foreach (string msg in msgArray.Skip(5).Take(msgArray.Length - 6))
                    {
                        data.Add(msg);
                    }
                    result.Data = data;
                    result.State = true;
                }
                else
                {
                    result.Message = $"消息格式错误,解析到消息有效数据长度为8位,但是没有Error标识,接收到的消息为: {msgRec}";
                }

            }
            catch (Exception ex)
            {
                result.Message = ex.GetFullException();
                return result;
            }
            return result;
        }

        /// <summary>
        ///  检测3D工位的数据
        ///  PC3,	35,	0,	2018,	20230717000020800,	136.482,	32.0614,	26.3326,	25.2252,	121.433,	153.494,	0,	1693	, 0,	1678, 	0,	3371,	 End
        ///  3D工位	数据长度	相机号	流水号	时间戳	平均厚度	ttv	线痕最大值	翘曲	最小厚度	最大厚度	是否密集线痕	上线痕数量	上线痕数量最大值	下线痕数量	下线痕数量最大值	线痕数量	结束符
        /// </summary>
        /// <param name="msgRec"></param>
        /// <returns></returns>
        public static DataResult<List<string>> Parse3DClientMsg(string msgRec)
        {
            DataResult<List<string>> result = new DataResult<List<string>>();
            try
            {
                // 保留空字符串,但是去除掉分隔后字符串两侧的空格
                string[] msgArray = msgRec.Split(',', StringSplitOptions.TrimEntries);
                if (msgArray.Length != 18 && msgArray.Length != 8)
                {
                    result.Message = $"消息长度错误,错误的消息为:{msgRec},解析逗号分隔之后长度为: {msgArray.Length},预设的长度为: (35,15),去除逗号之后为(18,8)";
                    return result;
                }

                string pcName = msgArray[0];
                string cameraNum = msgArray[2];
                string waferId = msgArray[3];
                if (msgArray.Length == 8)
                {
                    if (msgArray[5] == "ERROR")
                    {
                        string errorType = msgArray[6];
                        List<string> data = new List<string>()
                        {
                            waferId,
                            pcName,
                            cameraNum,
                            errorType
                        };
                        result.Data = data;
                        result.State = true;
                    }
                    else if (msgArray[5] == "Clear")
                    {
                        string ClearIsOK = msgArray[5] + msgArray[6];
                        List<string> data = new List<string>()
                        {
                            waferId,
                            pcName,
                            cameraNum,
                            ClearIsOK
                        };
                        result.Data = data;
                        result.State = true;
                    }
                    else if (msgArray[5] == "Correct")
                    {
                        string calibrationRes = msgArray[5] + msgArray[6];
                        List<string> data = new List<string>()
                        {
                            waferId,
                            pcName,
                            cameraNum,
                            calibrationRes
                        };
                        result.Data = data;
                        result.State = true;
                    }
                }
                else if (msgArray.Length == 18)
                {
                    List<string> data = new List<string>()
                    {
                        waferId,
                        pcName,
                        cameraNum,
                    };
                    foreach (string msg in msgArray.Skip(5).Take(msgArray.Length - 6))
                    {
                        data.Add(msg);
                    }
                    result.Data = data;
                    result.State = true;
                }
                else
                {
                    result.Message = $"消息格式错误,解析到消息有效数据长度为8位,但是没有Error标识,接收到的消息为: {msgRec}";
                }
            }
            catch (Exception ex)
            {
                result.Message = ex.GetFullException();
            }
            return result;
        }

        /// <summary>
        /// 脏污工位的消息解析. 脏污数据分为下脏污和上脏污
        /// PC4	 25	0	2018 20230708000100	0	0	0	0	0	0	0	End   (下脏污)
        /// 脏污工位	数据长度	相机号	流水号	时间戳	下脏污有无	下脏污面积	下脏污数量	下脏污穿孔有无	下脏污穿孔数量	下脏污缺口有无	下脏污孔洞数量	结束符
        /// PC4	25	1	2018	20230708000100	0	0	0	0	0	0	0	End   (上脏污)
        ///  脏污工位	数据长度	相机号	流水号	时间戳	上脏污有无	上脏污面积	上脏污数量	上脏污穿孔有无	上脏污穿孔数量	上脏污缺口有无	上脏污孔洞数量	结束符
        /// </summary>
        /// <param name="msgRec"></param>
        /// <returns></returns>
        public static DataResult<List<string>> ParseSmudgeClientMsg(string msgRec)
        {
            DataResult<List<string>> result = new DataResult<List<string>>();
            try
            {
                // 保留空字符串,但是去除掉分隔字符串两侧的空格
                string[] msgArray = msgRec.Split(',', StringSplitOptions.TrimEntries);
                if (msgArray.Length != 13 && msgArray.Length != 8)
                {
                    result.Message = $"消息长度错误,错误的消息为:{msgRec},解析逗号分隔之后长度为: {msgArray.Length},预设的长度为: (25,15),去除逗号之后为(13,8)";
                    return result;
                }

                string pcName = msgArray[0];
                string cameraNum = msgArray[2];
                string waferId = msgArray[3];
                if (msgArray.Length == 8)
                {
                    if (msgArray[5] == "ERROR")
                    {
                        string errorType = msgArray[6];
                        List<string> data = new List<string>()
                        {
                            waferId,
                            pcName,
                            cameraNum,
                            errorType
                        };
                        result.Data = data;
                        result.State = true;
                    }
                    else if (msgArray[5] == "Clear")
                    {
                        string ClearIsOK = msgArray[5] + msgArray[6];
                        List<string> data = new List<string>()
                        {
                            waferId,
                            pcName,
                            cameraNum,
                            ClearIsOK
                        };
                        result.Data = data;
                        result.State = true;
                    }
                }
                else if (msgArray.Length == 13)
                {
                    List<string> data = new List<string>()
                    {
                        waferId,
                        pcName,
                        cameraNum,
                    };
                    foreach (string msg in msgArray.Skip(5).Take(msgArray.Length - 6))
                    {
                        data.Add(msg);
                    }
                    result.Data = data;
                    result.State = true;
                }
                else
                {
                    result.Message = $"消息格式错误,解析到消息有效数据长度为8位,但是没有Error标识,接收到的消息为: {msgRec}";
                }
            }
            catch (Exception ex)
            {
                result.Message = ex.GetFullException();
            }
            return result;
        }

        /// <summary>
        /// 隐裂工位消息解析
        /// PC5	  43	 0	  2018	 2023071700002400	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	End
        /// 隐裂工位	数据长度	相机号	流水号	时间戳	前隐裂有无	前隐裂面积	前隐裂数量	前崩边有无	前崩边面积	前崩边数量	
        /// 前孔洞有无	前孔洞数量	后隐裂有无	后隐裂面积	后隐裂数量	后崩边有无	后崩边面积	后崩边数量	后孔洞有无	后孔洞数量	结束符
        /// </summary>
        /// <param name="msgRec"></param>
        /// <returns></returns>
        public static DataResult<List<string>> ParseSubfissureClientMsg(string msgRec)
        {
            DataResult<List<string>> result = new DataResult<List<string>>();
            try
            {
                // 保留空字符串,但是去除掉字符串分隔后两侧的空格
                string[] msgArray = msgRec.Split(',', StringSplitOptions.TrimEntries);
                if (msgArray.Length != 22 && msgArray.Length != 8)
                {
                    result.Message = $"消息长度错误,错误的消息为:{msgRec},解析逗号分隔之后长度为: {msgArray.Length},预设的长度为: (43,15),去除逗号之后为(22,8)";
                    return result;
                }

                string pcName = msgArray[0];
                string cameraNum = msgArray[2];
                string waferId = msgArray[3];
                if (msgArray.Length == 8)
                {
                    if (msgArray[5] == "ERROR")
                    {
                        string errorType = msgArray[6];
                        List<string> data = new List<string>()
                        {
                            waferId,
                            pcName,
                            cameraNum,
                            errorType
                        };
                        result.Data = data;
                        result.State = true;
                    }
                    else if (msgArray[5] == "Clear")
                    {
                        string ClearIsOK = msgArray[5] + msgArray[6];
                        List<string> data = new List<string>()
                        {
                            waferId,
                            pcName,
                            cameraNum,
                            ClearIsOK
                        };
                        result.Data = data;
                        result.State = true;
                    }
                }
                else if (msgArray.Length == 22)
                {
                    List<string> data = new List<string>()
                    {
                        waferId,
                        pcName,
                        cameraNum,
                    };
                    foreach (string msg in msgArray.Skip(5).Take(msgArray.Length - 6))
                    {
                        data.Add(msg);
                    }
                    result.Data = data;
                    result.State = true;
                }
                else
                {
                    result.Message = $"消息格式错误,解析到消息有效数据长度为8位,但是没有Error标识,接收到的消息为: {msgRec}";
                }
            }
            catch (Exception ex)
            {
                result.Message = ex.GetFullException();
            }
            return result;
        }


        public static DataResult UpdateWaferIdSummaryTask(int waferId)
        {
            DataResult res = new DataResult();
            try
            {
                GlobalValues.WaferIdDateSummary[waferId] = DateTime.Now;
                res.State = true;
            }
            catch (Exception ex)
            {
                LoggerHelper.WriteLogMain(ex.GetFullException(), LogType.Exception);
                res.Message = ex.Message;
                return res;
            }
            return res;
        }


        public static Dictionary<string, string> VisionErrorCodeMap = new Dictionary<string, string>()
        {
             {"00","3D工位误触发" },
            {"01","连片" },
            {"02","反向" },
            {"03","遮挡" },
            {"04","碎片" },
            {"05","错位" },
            {"06","PLC通讯异常" },
            {"07","3D数据错乱" }
        };
    }
}
